[CF733F]Drivers Dissatisfaction

题目

传送门

题解

我们应该明白的第一件事——所有的花费只会全部花在一条边上，这是这道题的基础 虽然我知道也没第一时间做出来

下文称这条边为“\(JZM\)”.

然后，随便找一个 \(MST\)，然后我们对于这条 \(JZM\) 应该会出现在哪里分类讨论：

1. 出现在树边上，显然 \(JZM\) 应该是 \(c\) 最小的那条边，只有这样才能最大地减少整棵树的花费；
2. 出现在非树边上，对于一条边 \((u,v)\)，如果我们要选择它成为 \(JZM\)，无疑会破坏树结构，考虑在 \(u,v\) 树上路径去掉一条边以维持树结构，显然去掉的边应该是权值最大的，然后，我们再全部把花费砸在我们加进来这条边，和答案进行比较即可；

由于答案要输出具体方案，需要保存哪条边是 \(JZM\).

代码

#include<cstdio>
#include<vector>
#include<algorithm>
using namespace std;

#define rep(i,__l,__r) for(signed i=(__l),i##_end_=(__r);i<=i##_end_;++i)
#define fep(i,__l,__r) for(signed i=(__l),i##_end_=(__r);i>=i##_end_;--i)
#define erep(i,u) for(signed i=tail[u],v=e[i].to;i;i=e[i].nxt,v=e[i].to)
#define writc(a,b) fwrit(a),putchar(b)
#define mp(a,b) make_pair(a,b)
#define ft first
#define sd second
typedef long long LL;
typedef pair<int,int> pii;
typedef unsigned long long ull;
typedef unsigned uint;
#define Endl putchar('\n')
// #define int long long
// #define int unsigned
// #define int unsigned long long

#define cg (c=getchar())
template<class T>inline void read(T& x){
    char c;bool f=0;
    while(cg<'0'||'9'<c)f|=(c=='-');
    for(x=(c^48);'0'<=cg&&c<='9';x=(x<<1)+(x<<3)+(c^48));
    if(f)x=-x;
}
template<class T>inline T read(const T sample){
    T x=0;char c;bool f=0;
    while(cg<'0'||'9'<c)f|=(c=='-');
    for(x=(c^48);'0'<=cg&&c<='9';x=(x<<1)+(x<<3)+(c^48));
    return f?-x:x;
}
template<class T>void fwrit(const T x){//just short,int and long long
    if(x<0)return (void)(putchar('-'),fwrit(-x));
    if(x>9)fwrit(x/10);
    putchar(x%10^48);
}
template<class T>inline T Max(const T x,const T y){return x<y?y:x;}
template<class T>inline T Min(const T x,const T y){return x<y?x:y;}
template<class T>inline T fab(const T x){return x>0?x:-x;}
inline int gcd(const int a,const int b){return b?gcd(b,a%b):a;}
inline void getInv(int inv[],const int lim,const int MOD){
    inv[0]=inv[1]=1;for(int i=2;i<=lim;++i)inv[i]=1ll*inv[MOD%i]*(MOD-MOD/i)%MOD;
}
inline LL mulMod(const LL a,const LL b,const LL mod){//long long multiplie_mod
    return ((a*b-(LL)((long double)a/mod*b+1e-8)*mod)%mod+mod)%mod;
}

const int maxm=2e5;
const int maxn=2e5;
const int logmaxn=17;
const int inf=(1<<30)-1;

/** @param id 边的原编号*/
struct edge{int u,v,w,id;
    inline bool operator <(const edge rhs)const{
        return w<rhs.w;
    }
}es[maxm+5];

/** @brief 以原编号为下标*/
int w[maxm+5],c[maxm+5],intre[maxm+5];

/** @brief 记录最终答案*/
LL ans;
/** @brief 记录哪个树上边被删掉*/
int delet;

/** @param id 这条边的原编号*/
struct node{int to,w,id;};
vector<node>G[maxn+5];
inline void add_edge(const int u,const int v,const int w,const int id){
    G[u].push_back(node{v,w,id});
    G[v].push_back(node{u,w,id});
}

int n,m,s;

inline void Init(){
    n=read(1),m=read(1);
    rep(i,1,m)w[i]=read(1);
    rep(i,1,m)c[i]=read(1);
    int u,v;
    rep(i,1,m){
        u=read(1),v=read(1);
        es[i]=edge{u,v,w[i],i};
    }s=read(1);
}

/** @brief 最小生成树的代价*/
LL min_edge_sum;
/** @brief 最小边的花费, 始终记录 MST 的最小边花费*/
int min_cost=inf;
/** @brief 记录把钱全部花在哪条边上, 记录原编号, 不一定记录 MST 的信息*/
int min_cost_id;

/** @brief dsu, 用于处理 MST*/
int fa[maxn+5];
inline void build(){rep(i,1,n)fa[i]=i;}
int root(const int u){return fa[u]==u?u:fa[u]=root(fa[u]);}

inline void Get_MST(){
    sort(es+1,es+m+1);
    build();
    rep(i,1,m)if(root(es[i].u)!=root(es[i].v)){
        min_edge_sum+=es[i].w;
        // printf("chooce edge %d\n",es[i].id);
        intre[es[i].id]=1;
        fa[fa[es[i].v]]=fa[es[i].u];
        add_edge(es[i].u,es[i].v,es[i].w,es[i].id);
        if(c[es[i].id]<min_cost){
            min_cost=c[es[i].id];
            min_cost_id=es[i].id;
        }
    }
    // printf("min_cost == %d\n",min_cost);
    ans=min_edge_sum-s/min_cost;
}

/** @brief 跳跃数组*/
int f[maxn+5][logmaxn+5];
/** @brief 与 f[][] 配合使用, 记录最大边权和原编号*/
/** @param first 最大边的边权*/
/** @param second 最大边的原编号*/
pii g[maxn+5][logmaxn+5];
/** @brief 最小生成树每个点的深度*/
int d[maxn+5];

void Dfs(const int u,const int pre){
    // printf("Now u == %d, pre == %d\n",u,pre);
    d[u]=d[pre]+1;
    rep(j,1,logmaxn){
        f[u][j]=f[f[u][j-1]][j-1];
        g[u][j]=Max(g[u][j-1],g[f[u][j-1]][j-1]);
    }
    for(auto it:G[u])if(it.to!=pre){
        f[it.to][0]=u,g[it.to][0]=mp(it.w,it.id);
        Dfs(it.to,u);
    }
}

inline void update(int& u,const int up,pii& ret){
    fep(j,logmaxn,0)if(d[f[u][j]]>=up)
        ret=Max(ret,g[u][j]),u=f[u][j];
}
/** @brief 得到生成树两点间最大边的原编号*/
inline int get_maxid(int u,int v){
    pii ret=mp(0,0);
    if(d[u]<d[v])swap(u,v);
    update(u,d[v],ret);
    if(u==v)return ret.sd;
    fep(j,logmaxn,0)if(f[u][j]!=f[v][j]){
        ret=Max(ret,Max(g[u][j],g[v][j]));
        u=f[u][j],v=f[v][j];
    }ret=Max(ret,Max(g[u][0],g[v][0]));
    return ret.sd;
}

/** @brief 尝试能否钦定将所有花费花在边 es[i].id 并得到更优答案*/
inline void Try_to_replace(const int i){
    // printf("Now replace %d\n",i);
    int u=es[i].u,v=es[i].v;
    int id=get_maxid(u,v);
    LL tmp=min_edge_sum-w[id]+es[i].w-s/c[es[i].id];
    if(tmp<ans){
        ans=tmp;
        delet=id;
        min_cost_id=es[i].id;
    }
}

inline void writ_ans(){
    writc(ans,'\n');
    rep(i,1,m)if((intre[i] && i!=delet) || i==min_cost_id){
        writc(i,' ');
        if(min_cost_id==i)writc(w[i]-s/c[i],'\n');
        else writc(w[i],'\n');
    }
}

signed main(){
    Init();
    Get_MST();
    Dfs(1,0);
    rep(i,1,m)if(!intre[es[i].id] && c[es[i].id]<min_cost)
        Try_to_replace(i);
    // printf("after try\n");
    writ_ans();
    return 0;
}