Codeforces Round #378 (Div. 2) F

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+7;
const int M=2e6+7;
const int inf=0x3f3f3f3f;
const ll INF=0x3f3f3f3f3f3f3f3f;
const int mod=1e9+7;

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

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

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=0;
    for(int i=1;i<=n;i++)
        fa[i]=i;

    sort(e,e+m);

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

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

        dfs(v,u);
    }
}

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

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

    return nx[a][0];
}

int getMxIdPath(int a,int b)
{
    int lca=getLca(a,b);
    int ret=-1;
    for(int i=19;i>=0;i--)
    {
        if(nx[a][i]!=-1 && depth[nx[a][i]]>=depth[lca])
        {
            ret=getMxId(ret,mx[a][i]);
            a=nx[a][i];
        }
        if(nx[b][i]!=-1 && 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=0;i<m;i++)
        read(e[i].w);

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

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

    read(s);

    ll cost=kruscal();

    dfs(1,-1);

    ll ans=cost, p=0;

    for(int id=0;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
",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
",t.first+1,t.second);

    return 0;
}
/*
*/