luogu3651 展翅翱翔之时 (はばたきのとき)[基环树+贪心]

考前随便做点水题愉♂悦身心 有助于退役

这题意思其实就是说要把外向基环树森林改成一个环的最小代价。

依照套路，先对每棵基环树的树做dp，这里因为要是环，要把所有的树都拆成链，然后连接。所以考虑以最小代价拆掉每一个树。

因为对于树的每层，只能选择出一个儿子作为链的部分保留下来，所以贪心的尽量选权值大的儿子留下来，其他的全部作为另一条链的开头准备接到环上。

所以树的部分就是一个简单的树形DP。

然后看环上的DP，相当于是要把我们之前搞出来的所有的链全部接上去，所以环上至少要有一个边断开，让这些链接上去。

所以环上，每条边要么把入点连着的链断开，接入环中某处，要么直接断掉这条边将一些链给接上去。

这时只要对环上每条边以这两种方案择优选取，最后发现最优方案如果没有环上边被断开，就强制找一个最小的代价让环上边断掉。

当图是一个基环树森林的时候，不影响正确性，我们需要让每棵树的环都断开一个，以互相接入成为环，所以每个基环树可以独立做。

不过注意一个特例：整个图就是一个环，这时就不需要断了。

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<cmath>
 #include<queue>
 #define mst(x) memset(x,0,sizeof x)
 #define dbg(x) cerr << #x << " = " << x <<endl
 #define dbg2(x,y) cerr<< #x <<" = "<< x <<"  "<< #y <<" = "<< y <<endl
 using namespace std;
 typedef long long ll;
 typedef double db;
 typedef pair<int,int> pii;
 template<typename T>inline T _min(T A,T B){return A<B?A:B;}
 template<typename T>inline T _max(T A,T B){return A>B?A:B;}
 template<typename T>inline char MIN(T&A,T B){return A>B?(A=B,):;}
 template<typename T>inline char MAX(T&A,T B){return A<B?(A=B,):;}
 template<typename T>inline void _swap(T&A,T&B){A^=B^=A^=B;}
 template<typename T>inline T read(T&x){
     x=;int f=;char c;while(!isdigit(c=getchar()))if(c=='-')f=;
     while(isdigit(c))x=x*+(c&),c=getchar();return f?x=-x:x;
 }
 const int N=1e5+,INF=0x3f3f3f3f;
 struct thxorz{
     int head[N],nxt[N<<],to[N<<],tot;
     thxorz(){tot=;}
     inline void add(int x,int y){
         to[++tot]=y,nxt[tot]=head[x],head[x]=tot;
         to[++tot]=x,nxt[tot]=head[y],head[y]=tot;
     }
 }G;
 ll ans;
 int n;
 #define y G.to[j]
 int vis[N],lp[N],val[N],chain[N],m,lpfa,flag,rt;
 void dfs(int x){//dbg(x);
     vis[x]=;
     for(register int j=G.head[x];j&&!flag;j=G.nxt[j])if(j&){//mistake:the direction of the edge!
         if(vis[y])return lpfa=y,flag=,lp[m=]=x,void();
         else{dfs(y);if(flag)lp[++m]=x;}
     }
     if(!flag)vis[x]=;
     if(x==lpfa)flag=;
 }
 void dp(int x){//dbg(x);
     vis[x]=;ll sum=;
     for(register int j=G.head[x];j;j=G.nxt[j])if(!vis[y])dp(y),sum+=val[y],MAX(chain[x],val[y]);
     ans+=sum-chain[x];
 }
 #undef y
 int main(){//freopen("test.in","r",stdin);//freopen("test.ans","w",stdout);
     read(n);
     for(register int i=,x;i<=n;++i)read(x),read(val[i]),G.add(x,i);
     for(register int i=;i<=n;++i)if(!vis[i]){//dbg(i);
         flag=,dfs(i);int chosen=;//dbg("ok");dbg(m);
         if(m==n)break;
         for(register int j=;j<=m;++j)dp(lp[j]);//dbg(lp[j]);
         #define nxt (j+1>m?1:j+1)//attention to the order..
         for(register int j=;j<=m;++j){
             if(chain[lp[j]]<val[lp[nxt]])ans+=chain[lp[j]];
             else ans+=val[lp[nxt]],chosen=;
         }
         if(!chosen){//dbg2(i,chosen);
             int tmp=INF;
             for(register int j=;j<=m;++j)MIN(tmp,-chain[lp[j]]+val[lp[nxt]]);
             ans+=tmp;
         }
     }
     printf("%lld\n",ans);
     return ;
 }

总结：这题也涉及一个断环的操作，不过是需要考察性质之后发现的，是一个不那么显然的题目。。。