Codeforces Round #378 (Div. 2) F - Drivers Dissatisfaction

F - Drivers Dissatisfaction

题目大意：给你n个点，m条边，每个边都有一个权重w，每条边也有一个c表示，消耗c元可以把这条边的权重减1，求最多消耗s元的最小生成树。

思路：因为一条边的权重没有下限所以s元肯定是用在一条边上的。 那么我们先跑一个最小生成树，把这棵最小生成树建出来，然后我们枚举用了

s元之后的边，如果这条边不在树上那么加上这条边之后肯定形成了一个环，最优的方案肯定是删掉这个环中权值最大的边再次变成一棵树。

对于边(u,v)来说，如果把这条边加上，那么删掉的边肯定在，u到 lca(u,v) 和 v到 lca(u,v)中的权值最大的那条边。 可以用倍增快速找边，就能解决

这个问题啦。  码起来好麻烦啊，借鉴了某个学长的代码。。

 #include<bits/stdc++.h>
 #define fi first
 #define se second
 #define mk make_pair
 #define ll long long
 #define pll pair<ll,ll>
 #define pil pair<int,ll>
 #define pli pair<ll,int>
 #define pii pair<int,int>
 #define read(x) scanf("%d",&x)
 #define sread(x) scanf("%s",x)
 #define dread(x) scanf("%lf",&x)
 #define lread(x) scanf("%lld",&x)
 using namespace std;

 const int N=2e5+;
 const int M=2e6+;
 const int inf=0x3f3f3f3f;
 const ll INF=0x3f3f3f3f3f3f3f3f;
 const int mod=1e9+;

 int n,m,tot,s,fa[N],depth[N],nx[N][],mx[N][];

 struct node
 {
     int u,v,w,c,id;
     bool operator < (const node &rhs)const
     {
         return w<rhs.w;
     }
 }e[N<<];

 bool cmp(node a,node b){
     return a.id<b.id;
 }
 vector<pii> edge[N];
 map<int,int> result;

 int Find(int x) {
     return x==fa[x]? x : fa[x]=Find(fa[x]);
 }

 ll kruscal()
 {
     ll ans=;
     for(int i=;i<=n;i++)
         fa[i]=i;

     sort(e,e+m);

     for(int i=;i<m;i++)
     {
         int u=e[i].u,v=e[i].v,w=e[i].w;
         int nx_u=Find(u);
         int nx_v=Find(v);
         if(nx_u!=nx_v)
         {
             edge[u].push_back(mk(v,e[i].id));
             edge[v].push_back(mk(u,e[i].id));

             fa[nx_u]=nx_v;
             ans+=w;
             result[e[i].id]=w;
         }
     }

     sort(e,e+m,cmp);

     return ans;
 }

 int getMxId(int a,int b)
 {
     if(a==-) return b;
     if(b==-) return a;
     return e[a].w>e[b].w? a : b;
 }
 void dfs(int u,int pre)
 {
     nx[u][]=pre;
     for(int i=;i<;i++)
     {
         if(nx[u][i-]!=-)
         {
             nx[u][i]=nx[nx[u][i-]][i-];
             mx[u][i]=getMxId(mx[u][i-],mx[nx[u][i-]][i-]);
         }
         else
             nx[u][i]=mx[u][i]=-;
     }

     for(auto t : edge[u])
     {
         int v=t.first;
         if(v==pre)
             continue;
         depth[v]=depth[u]+;
         mx[v][]=t.second;

         dfs(v,u);
     }
 }

 int getLca(int a,int b)
 {
     if(depth[a]<depth[b])
         swap(a,b);
     for(int i=;i<;i++)
         if(depth[a]-depth[b]>>i & )
             a=nx[a][i];

     if(a==b) return a;
     for(int i=;i>=;i--)
         if(nx[a][i]!=nx[b][i])
             a=nx[a][i],b=nx[b][i];

     return nx[a][];
 }

 int getMxIdPath(int a,int b)
 {
     int lca=getLca(a,b);
     int ret=-;
     for(int i=;i>=;i--)
     {
         if(nx[a][i]!=- && depth[nx[a][i]]>=depth[lca])
         {
             ret=getMxId(ret,mx[a][i]);
             a=nx[a][i];
         }
         if(nx[b][i]!=- && depth[nx[b][i]]>=depth[lca])
         {
             ret=getMxId(ret,mx[b][i]);
             b=nx[b][i];
         }
     }
     return ret;
 }

 int main()
 {
     read(n); read(m);

     for(int i=;i<m;i++)
         read(e[i].w);

     for(int i=;i<m;i++)
         read(e[i].c);

     for(int i=;i<m;i++)
     {
         read(e[i].u);
         read(e[i].v);
         e[i].id=i;
     }

     read(s);

     ll cost=kruscal();

     dfs(,-);

     ll ans=cost, p=;

     for(int id=;id<m;id++)
     {
         int big=getMxIdPath(e[id].u,e[id].v);
         ll tmp=cost-e[big].w+e[id].w-s/e[id].c;
         if(tmp<ans)
             ans=tmp,p=id;
     }

     printf("%lld\n",ans);
     result.erase(getMxIdPath(e[p].u,e[p].v));
     result[p]=e[p].w-s/e[p].c;

     for(auto t: result)
         printf("%d %d\n",t.first+,t.second);

     return ;
 }
 /*
 */